{
 "cells": [
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# 2、深层神经网络（DNN）分类模型和BN批归一化\n",
    "批归一化就是对输入数据进行归一化处理，使得数据分布变得更加均匀，从而使得神经网络训练更加稳定。可以消除梯度消失和梯度爆炸问题，提升模型的训练速度和精度。"
   ],
   "id": "9a9e3ebe59976f24"
  },
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-03-07T11:51:10.382544Z",
     "start_time": "2025-03-07T11:51:07.395964Z"
    }
   },
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import sklearn\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import os\n",
    "import sys\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "from torchvision import datasets\n",
    "from torchvision import transforms  # 将图片转换为tensor"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 打印系统信息",
   "id": "f3c64ea4099909e"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:51:10.398505Z",
     "start_time": "2025-03-07T11:51:10.382544Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)"
   ],
   "id": "72dd0977d9ab3976",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.9.1\n",
      "numpy 2.0.0\n",
      "pandas 2.2.2\n",
      "sklearn 1.6.1\n",
      "torch 2.6.0+cu126\n",
      "cuda:0\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 加载数据集以及数据预处理",
   "id": "956488e6eb4b09da"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:51:10.431804Z",
     "start_time": "2025-03-07T11:51:10.399509Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\n",
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor(),  # 将图片转换为tensor\n",
    "    transforms.Normalize((0.2860,), (0.3205,))  # 归一化\n",
    "])\n",
    "\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=transform\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=transform\n",
    ")\n",
    "\n",
    "# torchvision 数据集里没有提供训练集和验证集的划分\n",
    "# 当然也可以用 torch.utils.data.Dataset 实现人为划分\n",
    "# 从数据集到dataloader\n",
    "batch_size = 32\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size, shuffle=True)\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size, shuffle=False)"
   ],
   "id": "d61f817a330bce36",
   "outputs": [],
   "execution_count": 3
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 定义模型",
   "id": "2966ac26606f3dd7"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:51:10.442536Z",
     "start_time": "2025-03-07T11:51:10.431804Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, layers_num=2):\n",
    "        super().__init__()\n",
    "        self.transforms = transforms  # 预处理层，标准化\n",
    "        self.flatten = nn.Flatten()\n",
    "        # 多加几层\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 100),\n",
    "             # 这里先激活函数后batch norm，是因为batch norm 依赖于激活函数的输出\n",
    "            nn.BatchNorm1d(100),  # num of features=100\n",
    "            nn.SELU(),\n",
    "        )\n",
    "        # 加19层:所谓的DNN就是多个全连接层堆叠而成add_module()方法可以添加多个模块\n",
    "        for i in range(1, layers_num):\n",
    "            self.linear_relu_stack.add_module(f\"Linear_{i}\", nn.Linear(100, 100))\n",
    "            self.linear_relu_stack.add_module(f\"relu\", nn.ReLU())\n",
    "        # 输出层\n",
    "        self.linear_relu_stack.add_module(\"Output Layer\", nn.Linear(100, 10))\n",
    "\n",
    "        # 初始化权重\n",
    "        self.init_weights()\n",
    "\n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层的权重 W\"\"\"\n",
    "        # print('''初始化权重''')\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Linear):  #判断m是否为全连接层\n",
    "                nn.init.xavier_uniform_(m.weight)  # xavier 均匀分布初始化权重\n",
    "                nn.init.zeros_(m.bias)  # 全零初始化偏置项\n",
    "        # print('''初始化权重完成''')\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.flatten(x)\n",
    "        # 展平后 x.shape [batch size, 28 * 28]\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        # logits.shape [batch size, 10]\n",
    "        return logits\n",
    "\n",
    "\n",
    "model = NeuralNetwork(layers_num=10)\n",
    "total = 0\n",
    "# 计算模型参数数量\n",
    "for idx, (key, value) in enumerate(NeuralNetwork(20).named_parameters()):\n",
    "    # print(f\"Linear_{idx // 2:>02}\\tparamerters num: {np.prod(value.shape)}\") #np.prod是计算张量的元素个数\n",
    "    # print(f\"Linear_{idx // 2:>02}\\tshape: {value.shape}\")\n",
    "    total += np.prod(value.shape)\n",
    "total  #模型参数数量\n"
   ],
   "id": "16d13c2bd4b8f1c",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.int64(271610)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 定义损失函数和优化器",
   "id": "66503fb2eb5810ac"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:51:10.445929Z",
     "start_time": "2025-03-07T11:51:10.443541Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_func = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用SGD\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)"
   ],
   "id": "ca80a005b78c0afc",
   "outputs": [],
   "execution_count": 5
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 定义评估函数",
   "id": "ef6103735ff54269"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:51:10.479759Z",
     "start_time": "2025-03-07T11:51:10.445929Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_func):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_func(logits, labels)  # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        preds = logits.argmax(axis=-1)  # 验证集预测\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "id": "e07a932471c62b30",
   "outputs": [],
   "execution_count": 6
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 训练函数",
   "id": "bf9e838c8880bb56"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:51:10.484463Z",
     "start_time": "2025-03-07T11:51:10.479759Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 训练\n",
    "def training(\n",
    "        model,\n",
    "        train_loader,\n",
    "        val_loader,\n",
    "        epoch,\n",
    "        loss_func,\n",
    "        optimizer,\n",
    "        tensorboard_callback=None,\n",
    "        save_ckpt_callback=None,\n",
    "        early_stop_callback=None,\n",
    "        eval_step=500,\n",
    "):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "\n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_func(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())\n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "\n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_func)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "\n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step,\n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                        )\n",
    "\n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "\n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    return record_dict\n"
   ],
   "id": "c93f8daf4b9d6a13",
   "outputs": [],
   "execution_count": 7
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:53:32.163599Z",
     "start_time": "2025-03-07T11:51:10.484463Z"
    }
   },
   "cell_type": "code",
   "source": [
    "epoch = 10\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model,\n",
    "    train_loader,\n",
    "    val_loader,\n",
    "    epoch,\n",
    "    loss_func,\n",
    "    optimizer,\n",
    "    eval_step=len(train_loader)\n",
    ")"
   ],
   "id": "6cdf36529cdff089",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/18750 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "95d61686fa884b3ba32e41eb50f0025f"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 8
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:53:32.257242Z",
     "start_time": "2025-03-07T11:53:32.163599Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "    # print(train_df.head())\n",
    "    # print(val_df.head())\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)  #因为有loss和acc两个指标，所以画个子图\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))  #fig_num个子图，figsize是子图大小\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        #index是步数，item是指标名字\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        x_data = range(0, train_df.index[-1], 5000)  #每隔5000步标出一个点\n",
    "        axs[idx].set_xticks(x_data)\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{int(x / 1000)}k\", x_data))  #map生成labal\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_learning_curves(record, sample_step=500)  #横坐标是 steps"
   ],
   "id": "1f22e16c1c4d2ac5",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 9
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:53:33.630391Z",
     "start_time": "2025-03-07T11:53:32.257242Z"
    }
   },
   "cell_type": "code",
   "source": [
    "model.eval()\n",
    "loss, acc = evaluating(model, val_loader, loss_func)\n",
    "print(f\"loss:{loss:.4f}\\naccuracy:{acc:.4f}\")"
   ],
   "id": "93e65419197c734a",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:0.3480\n",
      "accuracy:0.8756\n"
     ]
    }
   ],
   "execution_count": 10
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
